/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#ifndef _CV_VM_H_
#define _CV_VM_H_

/*----------------------- Internal ViewMorphing Functions ------------------------------*/

/*======================================================================================*/

typedef struct CvMatrix4 {
	float m[4][4];
}
CvMatrix4;


/* Scanline section. Find coordinates by fundamental matrix */

/* Epsilon and real zero */
#define EPSILON             1.e-4
//#define REAL_ZERO(x)        ( (x) < EPSILON && (x) > -EPSILON)
#define REAL_ZERO(x) ( (x) < 1e-8 && (x) > -1e-8)

#define SIGN(x)				( (x)<0 ? -1:((x)>0?1:0 ) )

CvStatus  icvMakeScanlinesLengths( int*        scanlines,
								   int         numlines,
								   int*        lens);

/*=============================== PreWarp section ======================================*/

CV_INLINE int icvGetColor(uchar* valueRGB);

CvStatus  icvFindRunsInOneImage(
	int     numLines,       /* number of scanlines		*/
	uchar*  prewarp,        /* prewarp image 			*/
	int*    line_lens,      /* line lengths in pixels	*/
	int*    runs,           /* result runs				*/
	int*    num_runs);

/*================================ Morphing section ====================================*/

CvStatus  icvMorphEpilines8uC3(    uchar*  first_pix, /* raster epiline from the first image       */
								   uchar*  second_pix, /* raster epiline from the second image      */
								   uchar*  dst_pix,    /* raster epiline from the destination image */
								   /* (it's an output parameter)                */
								   float   alpha,      /* relative position of camera               */
								   int*    first,      /* first sequence of runs                    */
								   int     first_runs, /* it's length                               */
								   int*    second,     /* second sequence of runs                   */
								   int     second_runs,
								   int*    first_corr, /* correspond information for the 1st seq    */
								   int*    second_corr,
								   int     dst_len);   /* correspond information for the 2nd seq    */

/*========================== Dynamic correspond section ================================*/

CvStatus  icvDynamicCorrespond(   int*  first,         /* first sequence of runs           */
								  /* s0|w0|s1|w1|...|s(n-1)|w(n-1)|sn */
								  int   first_runs,    /* number of runs                   */
								  int*  second,        /* second sequence of runs          */
								  int   second_runs,
								  int*  first_corr,    /* s0'|e0'|s1'|e1'|...              */
								  int*  second_corr );

/*============================= PostWarp Functions =====================================*/

CvStatus  icvFetchLine8uC3R(
	uchar*   src,  int   src_step,
	uchar*   dst,  int*  dst_num,
	CvSize  src_size,
	CvPoint start,
	CvPoint end );

CvStatus  icvDrawLine8uC3R(
	uchar*   src,  int  src_num,
	uchar*   dst,  int  dst_step,
	CvSize  dst_size,
	CvPoint start,
	CvPoint end );


/*============================== Fundamental Matrix Functions ==========================*/
CvStatus  icvPoint7(  int*        points1,
					  int*        points2,
					  double*     F,
					  int*        amount
				   );

CvStatus  icvCubic(      double a2, double a1,
						 double a0, double* squares );

double icvDet( double* M );
double   icvMinor( double* M, int x, int y );

int
icvGaussMxN( double* A, double* B, int M, int N, double** solutions );

CvStatus
icvGetCoef( double* f1, double* f2, double* a2, double* a1, double* a0 );

/*================================= Scanlines Functions ================================*/

CvStatus  icvGetCoefficient(  CvMatrix3*     matrix,
							  CvSize         imgSize,
							  int*            scanlines_1,
							  int*            scanlines_2,
							  int*            numlines);

CvStatus  icvGetCoefficientDefault(   CvMatrix3*     matrix,
									  CvSize         imgSize,
									  int*            scanlines_1,
									  int*            scanlines_2,
									  int*            numlines);

CvStatus  icvGetCoefficientStereo(    CvMatrix3*     matrix,
									  CvSize         imgSize,
									  float*          l_epipole,
									  float*          r_epipole,
									  int*            scanlines_1,
									  int*            scanlines_2,
									  int*            numlines
								 );

CvStatus  icvGetCoefficientOrto(  CvMatrix3*     matrix,
								  CvSize         imgSize,
								  int*            scanlines_1,
								  int*            scanlines_2,
								  int*            numlines);


CvStatus  icvGetCrossEpilineFrame(    CvSize     imgSize,
									  float*      epiline,
									  int*        x1,
									  int*        y1,
									  int*        x2,
									  int*        y2
								 );

CvStatus  icvBuildScanlineLeftStereo(
	CvSize         imgSize,
	CvMatrix3*     matrix,
	float*          l_epipole,
	float*          l_angle,
	float           l_radius,
	int*            scanlines_1,
	int*            scanlines_2,
	int*            numlines);

CvStatus  icvBuildScanlineRightStereo(
	CvSize         imgSize,
	CvMatrix3*     matrix,
	float*          r_epipole,
	float*          r_angle,
	float           r_radius,
	int*            scanlines_1,
	int*            scanlines_2,
	int*            numlines);

CvStatus  icvGetStartEnd1(
	CvMatrix3*     matrix,
	CvSize         imgSize,
	float*          l_start_end,
	float*          r_start_end );

CvStatus  icvGetStartEnd2(
	CvMatrix3*     matrix,
	CvSize         imgSize,
	float*          l_start_end,
	float*          r_start_end );

CvStatus  icvGetStartEnd3(
	CvMatrix3*     matrix,
	CvSize         imgSize,
	float*          l_start_end,
	float*          r_start_end );

CvStatus  icvGetStartEnd4(
	CvMatrix3*     matrix,
	CvSize         imgSize,
	float*          l_start_end,
	float*          r_start_end );

CvStatus  icvBuildScanlineLeft(
	CvMatrix3*     matrix,
	CvSize         imgSize,
	int*            scanlines_1,
	int*            scanlines_2,
	float*          l_start_end,
	int*            numlines
);

CvStatus  icvBuildScanlineRight(
	CvMatrix3*     matrix,
	CvSize         imgSize,
	int*            scanlines_1,
	int*            scanlines_2,
	float*          r_start_end,
	int*            numlines
);


/*=================================== LMedS Functions ==================================*/
CvStatus  icvLMedS7(
	int*            points1,
	int*            points2,
	CvMatrix3*     matrix);


CvStatus  icvLMedS(   int*    points1,
					  int*    points2,
					  int     numPoints,
					  CvMatrix3* fundamentalMatrix );


/*
CvStatus  icvFindFundamentalMatrix(
                                    int*            points1,
                                    int*            points2,
                                    int             numpoints,
                                    int             method,
                                    CvMatrix3*      matrix);
*/
void   icvChoose7(	int*    ml,     int* mr,
					int     num,	int* ml7,
					int*   mr7 );

double icvMedian(	int* ml, int* mr,
					int num, double* F );

int icvBoltingPoints( int* ml,	    int* mr,
					  int num,        double* F,
					  double Mj,      int* *new_ml,
					  int* *new_mr,   int* new_num);

CvStatus  icvPoints8( int* ml, int* mr,
					  int num, double* F );

CvStatus  icvRank2Constraint( double* F );

CvStatus  icvSort( double* array, int length );

double icvAnalyticPoints8(	double* A,
							int num, double* F );

int icvSingularValueDecomposition(	int		M,
									int		N,
									double*	A,
									double*	W,
									int		get_U,
									double*	U,
									int		get_V,
									double*	V
								 );


/*======================================================================================*/
#endif/*_CV_VM_H_*/

